home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1997 July: Mac OS SDK / Dev.CD Jul 97 SDK1.toast / Development Kits (Disc 1) / QuickDraw GX / Programming Stuff / GX Libraries / CameraLibrary.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-04-07  |  4.6 KB  |  124 lines  |  [TEXT/MPS ]
  1.  
  2. /*
  3.     File:        CameraLibrary.c
  4.  
  5.     Contains:    graphics libraries - perspective gxMapping generation routines
  6.  
  7.     Written by:    Cary Clark, Georgiann Delaney, Michael Fairman, Dave Good, Robert Johnson, Keith McGreggor, Oliver Steele, David Van Brink, Chris Yerga
  8.  
  9.     Copyright:    © 1995 by Apple Computer, Inc., all rights reserved.
  10.  
  11.     Change History (most recent first):
  12.  
  13.          <3>      4/7/95    jtd        changed 'fract' to 'Fract'
  14.          <2>     1/24/95    JD        updated to latest GX 1.1 source (as of 16 Jan 1995)
  15.          <1>      1/9/95    JD        First checked in.
  16. */
  17.  
  18. #include "GraphicsLibraries.h"
  19. #include "CameraLibrary.h"
  20.  
  21.  
  22. camera* InitCamera(camera *obscura)
  23. {
  24.     obscura->location.x = 0;
  25.     obscura->location.y = 0;
  26.     obscura->location.z = -IntToFixed(1440);    /* 20 inches backward */
  27.     obscura->axis.x = 0;
  28.     obscura->axis.y = 0;
  29.     obscura->axis.z = fixed1;             /* forward */
  30.     obscura->zenith.x = 0;
  31.     obscura->zenith.y = -fixed1;          /* up */
  32.     obscura->zenith.z = 0;
  33.     obscura->observer.x = 0;
  34.     obscura->observer.y = 0;
  35.     obscura->observer.z = -IntToFixed(1440);    /* 20 inches backward */
  36.     return UpdateCamera(obscura);
  37. }
  38.  
  39. camera* UpdateCamera(camera *obscura)
  40. {
  41.     unit3D temp[2];
  42.     register unit3D *axis = temp;
  43.     register unit3D *zenith = axis + 1;
  44.     Unitize(&obscura->axis, axis);
  45.     {   register Fixed dot = FracDot((unit3D *)&obscura->zenith, axis);
  46.         zenith->x = obscura->zenith.x - FractMultiply(dot, axis->x);
  47.         zenith->y = obscura->zenith.y - FractMultiply(dot, axis->y);
  48.         zenith->z = obscura->zenith.z - FractMultiply(dot, axis->z);
  49.         Unitize((point3D *)zenith, zenith);
  50.     }
  51.     {   register unit3D *destPtr = (unit3D *)&obscura->orientation.map[0][0];
  52.         FracCross(axis, zenith, destPtr++);
  53.         *destPtr++ = *zenith;
  54.         *destPtr++ = *axis;
  55.     }
  56.     {   register Fixed *destPtr = &obscura->orientation.map[0][0];
  57.         register Fixed x = obscura->observer.x;
  58.         register Fixed y = obscura->observer.y;
  59.         register Fixed z = obscura->observer.z;
  60.         destPtr[0] = -FractMultiply(z, destPtr[0]) + FractMultiply(x, destPtr[6]);
  61.         destPtr[1] = -FractMultiply(z, destPtr[1]) + FractMultiply(x, destPtr[7]);
  62.         destPtr[2] = -FractMultiply(z, destPtr[2]) + FractMultiply(x, destPtr[8]);
  63.         destPtr[3] = FractMultiply(z, destPtr[3]) + FractMultiply(y, destPtr[6]);
  64.         destPtr[4] = FractMultiply(z, destPtr[4]) + FractMultiply(y, destPtr[7]);
  65.         destPtr[5] = FractMultiply(z, destPtr[5]) + FractMultiply(y, destPtr[8]);
  66.     }
  67.     return obscura;
  68. }
  69.  
  70. gxMapping* PatchToCameraMap(const patch *quilt, const camera *obscura, gxMapping *map)
  71. {
  72.     register Fixed *destPtr = &map->map[0][0];
  73.     register const Fixed *mapPtr = &obscura->orientation.map[0][0];
  74.     register Fixed *patchPtr;
  75.     point3D diff;
  76.     register Fixed dot;
  77.  
  78.     diff.x = quilt->origin.x - obscura->location.x;
  79.     diff.y = quilt->origin.y - obscura->location.y;
  80.     diff.z = quilt->origin.z - obscura->location.z;
  81.     dot = FracDot((unit3D *)&diff, (unit3D *)&obscura->orientation.map[2][0]);
  82.  
  83.     patchPtr = (Fixed *)quilt;
  84.     *destPtr++ = VectorMultiplyDivide(3, patchPtr, 1, mapPtr, 1, dot);
  85.     *destPtr++ = VectorMultiplyDivide(3, patchPtr, 1, mapPtr+3, 1, dot);
  86.     *destPtr++ = VectorMultiplyDivide(3, patchPtr, 1, mapPtr+6, 1, dot);
  87.     patchPtr += 3;
  88.     *destPtr++ = VectorMultiplyDivide(3, patchPtr, 1, mapPtr, 1, dot);
  89.     *destPtr++ = VectorMultiplyDivide(3, patchPtr, 1, mapPtr+3, 1, dot);
  90.     *destPtr++ = VectorMultiplyDivide(3, patchPtr, 1, mapPtr+6, 1, dot);
  91.     patchPtr = (Fixed *)&diff;
  92.     *destPtr++ = VectorMultiplyDivide(3, patchPtr, 1, mapPtr, 1, dot);
  93.     *destPtr++ = VectorMultiplyDivide(3, patchPtr, 1, mapPtr+3, 1, dot);
  94.     *destPtr = fract1;
  95.     return map;
  96. }
  97.  
  98. Fixed Unitize(const point3D *aPoint, unit3D *bPoint)
  99. {
  100.     register Fixed r = Magnitude(Magnitude(aPoint->x, aPoint->y), aPoint->z);
  101.     if (bPoint)
  102.     {   bPoint->x = FractDivide(aPoint->x, r);
  103.         bPoint->y = FractDivide(aPoint->y, r);
  104.         bPoint->z = FractDivide(aPoint->z, r);
  105.     }
  106.     return r;
  107. }
  108.  
  109. Fract FracDot(const unit3D *aPoint, const unit3D *bPoint)
  110. {
  111.     return FractMultiply(aPoint->x, bPoint->x) + FractMultiply(aPoint->y, bPoint->y) + FractMultiply(aPoint->z, bPoint->z);
  112. }
  113.  
  114. unit3D* FracCross(const unit3D *aPoint, const unit3D *bPoint, unit3D *cPoint)
  115. {
  116.     unit3D temp;
  117.     register Fract *tempPtr = (Fract *)&temp;
  118.     *tempPtr++ = FractMultiply(aPoint->y, bPoint->z) - FractMultiply(aPoint->z, bPoint->y);
  119.     *tempPtr++ = FractMultiply(aPoint->z, bPoint->x) - FractMultiply(aPoint->x, bPoint->z);
  120.     *tempPtr++ = FractMultiply(aPoint->x, bPoint->y) - FractMultiply(aPoint->y, bPoint->x);
  121.     *cPoint = temp;
  122.     return cPoint;
  123. }
  124.